
use crate::metadata::ir::*;
pub(crate) static REGISTERS: IR = IR {
    blocks: &[
        Block {
            name: "Adc",
            extends: None,
            description: Some("ADC1."),
            items: &[
                BlockItem {
                    name: "isr",
                    description: Some("ADC interrupt and status register."),
                    array: None,
                    byte_offset: 0x0,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Isr"),
                    }),
                },
                BlockItem {
                    name: "ier",
                    description: Some("ADC interrupt enable register."),
                    array: None,
                    byte_offset: 0x4,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Ier"),
                    }),
                },
                BlockItem {
                    name: "cr",
                    description: Some("ADC control register."),
                    array: None,
                    byte_offset: 0x8,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Cr"),
                    }),
                },
                BlockItem {
                    name: "cfgr",
                    description: Some("ADC configuration register."),
                    array: None,
                    byte_offset: 0xc,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Cfgr"),
                    }),
                },
                BlockItem {
                    name: "cfgr2",
                    description: Some("ADC configuration register 2."),
                    array: None,
                    byte_offset: 0x10,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Cfgr2"),
                    }),
                },
                BlockItem {
                    name: "smpr",
                    description: Some("sampling time register 1-2"),
                    array: Some(Array::Regular(RegularArray { len: 2, stride: 4 })),
                    byte_offset: 0x14,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Smpr"),
                    }),
                },
                BlockItem {
                    name: "pcsel",
                    description: Some("ADC channel preselection register."),
                    array: None,
                    byte_offset: 0x1c,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Pcsel"),
                    }),
                },
                BlockItem {
                    name: "sqr1",
                    description: Some("ADC regular sequence register 1."),
                    array: None,
                    byte_offset: 0x30,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Sqr1"),
                    }),
                },
                BlockItem {
                    name: "sqr2",
                    description: Some("ADC regular sequence register 2."),
                    array: None,
                    byte_offset: 0x34,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Sqr2"),
                    }),
                },
                BlockItem {
                    name: "sqr3",
                    description: Some("ADC regular sequence register 3."),
                    array: None,
                    byte_offset: 0x38,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Sqr3"),
                    }),
                },
                BlockItem {
                    name: "sqr4",
                    description: Some("ADC regular sequence register 4."),
                    array: None,
                    byte_offset: 0x3c,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Sqr4"),
                    }),
                },
                BlockItem {
                    name: "dr",
                    description: Some("ADC regular Data Register."),
                    array: None,
                    byte_offset: 0x40,
                    inner: BlockItemInner::Register(Register {
                        access: Access::Read,
                        bit_size: 32,
                        fieldset: Some("Dr"),
                    }),
                },
                BlockItem {
                    name: "jsqr",
                    description: Some("ADC injected sequence register."),
                    array: None,
                    byte_offset: 0x4c,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Jsqr"),
                    }),
                },
                BlockItem {
                    name: "ofr",
                    description: Some("ADC offset register."),
                    array: Some(Array::Regular(RegularArray { len: 4, stride: 4 })),
                    byte_offset: 0x60,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Ofr"),
                    }),
                },
                BlockItem {
                    name: "gcomp",
                    description: Some("ADC gain compensation register."),
                    array: None,
                    byte_offset: 0x70,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Gcomp"),
                    }),
                },
                BlockItem {
                    name: "jdr",
                    description: Some("ADC injected data register."),
                    array: Some(Array::Regular(RegularArray { len: 4, stride: 4 })),
                    byte_offset: 0x80,
                    inner: BlockItemInner::Register(Register {
                        access: Access::Read,
                        bit_size: 32,
                        fieldset: Some("Jdr"),
                    }),
                },
                BlockItem {
                    name: "awd2cr",
                    description: Some("ADC analog watchdog 2 configuration register."),
                    array: None,
                    byte_offset: 0xa0,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Awd2cr"),
                    }),
                },
                BlockItem {
                    name: "awd3cr",
                    description: Some("ADC analog watchdog 3 configuration register."),
                    array: None,
                    byte_offset: 0xa4,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Awd3cr"),
                    }),
                },
                BlockItem {
                    name: "ltr1",
                    description: Some("ADC watchdog threshold register 1."),
                    array: None,
                    byte_offset: 0xa8,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Ltr1"),
                    }),
                },
                BlockItem {
                    name: "htr1",
                    description: Some("ADC watchdog threshold register 1."),
                    array: None,
                    byte_offset: 0xac,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Htr1"),
                    }),
                },
                BlockItem {
                    name: "ltr2",
                    description: Some("ADC watchdog lower threshold register 2."),
                    array: None,
                    byte_offset: 0xb0,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Ltr2"),
                    }),
                },
                BlockItem {
                    name: "htr2",
                    description: Some("ADC watchdog higher threshold register 2."),
                    array: None,
                    byte_offset: 0xb4,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Htr2"),
                    }),
                },
                BlockItem {
                    name: "ltr3",
                    description: Some("ADC watchdog lower threshold register 3."),
                    array: None,
                    byte_offset: 0xb8,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Ltr3"),
                    }),
                },
                BlockItem {
                    name: "htr3",
                    description: Some("ADC watchdog higher threshold register 3."),
                    array: None,
                    byte_offset: 0xbc,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Htr3"),
                    }),
                },
                BlockItem {
                    name: "difsel",
                    description: Some("ADC differential mode selection register."),
                    array: None,
                    byte_offset: 0xc0,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Difsel"),
                    }),
                },
                BlockItem {
                    name: "calfact",
                    description: Some("ADC user control register."),
                    array: None,
                    byte_offset: 0xc4,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Calfact"),
                    }),
                },
                BlockItem {
                    name: "calfact2",
                    description: Some("ADC calibration factor register."),
                    array: None,
                    byte_offset: 0xc8,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Calfact2"),
                    }),
                },
            ],
        },
        Block {
            name: "Adc4",
            extends: None,
            description: Some("ADC4."),
            items: &[
                BlockItem {
                    name: "isr",
                    description: Some("ADC interrupt and status register."),
                    array: None,
                    byte_offset: 0x0,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Adc4Isr"),
                    }),
                },
                BlockItem {
                    name: "ier",
                    description: Some("ADC interrupt enable register."),
                    array: None,
                    byte_offset: 0x4,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Adc4Ier"),
                    }),
                },
                BlockItem {
                    name: "cr",
                    description: Some("ADC control register."),
                    array: None,
                    byte_offset: 0x8,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Adc4Cr"),
                    }),
                },
                BlockItem {
                    name: "cfgr1",
                    description: Some("ADC configuration register."),
                    array: None,
                    byte_offset: 0xc,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Adc4Cfgr1"),
                    }),
                },
                BlockItem {
                    name: "cfgr2",
                    description: Some("ADC configuration register 2."),
                    array: None,
                    byte_offset: 0x10,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Adc4Cfgr2"),
                    }),
                },
                BlockItem {
                    name: "smpr",
                    description: Some("ADC sample time register."),
                    array: None,
                    byte_offset: 0x14,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Adc4Smpr"),
                    }),
                },
                BlockItem {
                    name: "awd1tr",
                    description: Some("ADC watchdog threshold register."),
                    array: None,
                    byte_offset: 0x20,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Adc4Awdtr"),
                    }),
                },
                BlockItem {
                    name: "awd2tr",
                    description: Some("ADC watchdog threshold register."),
                    array: None,
                    byte_offset: 0x24,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Adc4Awdtr"),
                    }),
                },
                BlockItem {
                    name: "chselrmod0",
                    description: Some("ADC channel selection register [alternate]."),
                    array: None,
                    byte_offset: 0x28,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Adc4Chselrmod0"),
                    }),
                },
                BlockItem {
                    name: "chselrmod1",
                    description: Some("ADC channel selection register [alternate]."),
                    array: None,
                    byte_offset: 0x28,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Adc4Chselrmod1"),
                    }),
                },
                BlockItem {
                    name: "awd3tr",
                    description: Some("ADC watchdog threshold register."),
                    array: None,
                    byte_offset: 0x2c,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Adc4Awdtr"),
                    }),
                },
                BlockItem {
                    name: "dr",
                    description: Some("ADC data register."),
                    array: None,
                    byte_offset: 0x40,
                    inner: BlockItemInner::Register(Register {
                        access: Access::Read,
                        bit_size: 32,
                        fieldset: Some("Adc4Dr"),
                    }),
                },
                BlockItem {
                    name: "pwrr",
                    description: Some("ADC power register."),
                    array: None,
                    byte_offset: 0x44,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Adc4Pwrr"),
                    }),
                },
                BlockItem {
                    name: "awd2cr",
                    description: Some("ADC Analog Watchdog 2 Configuration register."),
                    array: None,
                    byte_offset: 0xa0,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Adc4Awdcr"),
                    }),
                },
                BlockItem {
                    name: "awd3cr",
                    description: Some("ADC Analog Watchdog 3 Configuration register."),
                    array: None,
                    byte_offset: 0xa4,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Adc4Awdcr"),
                    }),
                },
                BlockItem {
                    name: "calfact",
                    description: Some("ADC Calibration factor."),
                    array: None,
                    byte_offset: 0xc4,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Adc4Calfact"),
                    }),
                },
                BlockItem {
                    name: "or",
                    description: Some("ADC option register."),
                    array: None,
                    byte_offset: 0xd0,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Adc4Or"),
                    }),
                },
                BlockItem {
                    name: "ccr",
                    description: Some("ADC common configuration register."),
                    array: None,
                    byte_offset: 0x308,
                    inner: BlockItemInner::Register(Register {
                        access: Access::ReadWrite,
                        bit_size: 32,
                        fieldset: Some("Adc4Ccr"),
                    }),
                },
            ],
        },
    ],
    fieldsets: &[
        FieldSet {
            name: "Adc4Awdcr",
            extends: None,
            description: Some("ADC Analog Watchdog Configuration register."),
            bit_size: 32,
            fields: &[Field {
                name: "awdch",
                description: Some("AWDCH0."),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 1,
                array: Some(Array::Regular(RegularArray { len: 24, stride: 1 })),
                enumm: None,
            }],
        },
        FieldSet {
            name: "Adc4Awdtr",
            extends: None,
            description: Some("ADC watchdog threshold register."),
            bit_size: 32,
            fields: &[
                Field {
                    name: "lt3",
                    description: Some("LT3."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 12,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "ht3",
                    description: Some("HT3."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 16 }),
                    bit_size: 12,
                    array: None,
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Adc4Calfact",
            extends: None,
            description: Some("ADC Calibration factor."),
            bit_size: 32,
            fields: &[Field {
                name: "calfact",
                description: Some("CALFACT."),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 7,
                array: None,
                enumm: None,
            }],
        },
        FieldSet {
            name: "Adc4Ccr",
            extends: None,
            description: Some("ADC common configuration register."),
            bit_size: 32,
            fields: &[
                Field {
                    name: "presc",
                    description: Some("PRESC."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 18 }),
                    bit_size: 4,
                    array: None,
                    enumm: Some("Adc4Presc"),
                },
                Field {
                    name: "vrefen",
                    description: Some("VREFEN."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 22 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "vsensesel",
                    description: Some("VSENSESEL."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 23 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "vbaten",
                    description: Some("VBATEN."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 24 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Adc4Cfgr1",
            extends: None,
            description: Some("ADC configuration register."),
            bit_size: 32,
            fields: &[
                Field {
                    name: "dmaen",
                    description: Some("DMAEN."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "dmacfg",
                    description: Some("DMACFG."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 1 }),
                    bit_size: 1,
                    array: None,
                    enumm: Some("Adc4Dmacfg"),
                },
                Field {
                    name: "res",
                    description: Some("RES."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 2 }),
                    bit_size: 2,
                    array: None,
                    enumm: Some("Adc4Res"),
                },
                Field {
                    name: "scandir",
                    description: Some("SCANDIR."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 4 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "align",
                    description: Some("ALIGN."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 5 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "extsel",
                    description: Some("EXTSEL."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 6 }),
                    bit_size: 3,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "exten",
                    description: Some("EXTEN."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 10 }),
                    bit_size: 2,
                    array: None,
                    enumm: Some("Adc4Exten"),
                },
                Field {
                    name: "ovrmod",
                    description: Some("OVRMOD."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 12 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "cont",
                    description: Some("CONT."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 13 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "wait",
                    description: Some("WAIT."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 14 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "discen",
                    description: Some("DISCEN."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 16 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "chselrmod",
                    description: Some("CHSELRMOD."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 21 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "awd1sgl",
                    description: Some("AWD1SGL."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 22 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "awd1en",
                    description: Some("AWD1EN."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 23 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "awd1ch",
                    description: Some("AWD1CH."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 26 }),
                    bit_size: 5,
                    array: None,
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Adc4Cfgr2",
            extends: None,
            description: Some("ADC configuration register 2."),
            bit_size: 32,
            fields: &[
                Field {
                    name: "ovse",
                    description: Some("OVSE."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "ovsr",
                    description: Some("OVSR."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 2 }),
                    bit_size: 3,
                    array: None,
                    enumm: Some("Adc4OversamplingRatio"),
                },
                Field {
                    name: "ovss",
                    description: Some("OVSS."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 5 }),
                    bit_size: 4,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "tovs",
                    description: Some("TOVS."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 9 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "lftrig",
                    description: Some("LFTRIG."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 29 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Adc4Chselrmod0",
            extends: None,
            description: Some("ADC channel selection register [alternate]."),
            bit_size: 32,
            fields: &[Field {
                name: "chsel",
                description: Some("CHSEL."),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 1,
                array: Some(Array::Regular(RegularArray { len: 24, stride: 1 })),
                enumm: None,
            }],
        },
        FieldSet {
            name: "Adc4Chselrmod1",
            extends: None,
            description: Some("ADC channel selection register [alternate]."),
            bit_size: 32,
            fields: &[Field {
                name: "sq",
                description: Some("SQ"),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 4,
                array: Some(Array::Regular(RegularArray { len: 8, stride: 4 })),
                enumm: None,
            }],
        },
        FieldSet {
            name: "Adc4Cr",
            extends: None,
            description: Some("ADC control register."),
            bit_size: 32,
            fields: &[
                Field {
                    name: "aden",
                    description: Some("ADEN."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "addis",
                    description: Some("ADDIS."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 1 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "adstart",
                    description: Some("ADSTART."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 2 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "adstp",
                    description: Some("ADSTP."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 4 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "advregen",
                    description: Some("ADVREGEN."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 28 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "adcal",
                    description: Some("ADCAL."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 31 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Adc4Dr",
            extends: None,
            description: Some("ADC data register."),
            bit_size: 32,
            fields: &[Field {
                name: "data",
                description: Some("DATA."),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 16,
                array: None,
                enumm: None,
            }],
        },
        FieldSet {
            name: "Adc4Ier",
            extends: None,
            description: Some("ADC interrupt enable register."),
            bit_size: 32,
            fields: &[
                Field {
                    name: "adrdyie",
                    description: Some("ADRDYIE."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "eosmpie",
                    description: Some("EOSMPIE."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 1 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "eocie",
                    description: Some("EOCIE."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 2 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "eosie",
                    description: Some("EOSIE."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 3 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "ovrie",
                    description: Some("OVRIE."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 4 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "awdie",
                    description: Some("AWD1IE."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 7 }),
                    bit_size: 1,
                    array: Some(Array::Regular(RegularArray { len: 3, stride: 1 })),
                    enumm: None,
                },
                Field {
                    name: "eocalie",
                    description: Some("EOCALIE."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 11 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "ldordyie",
                    description: Some("LDORDYIE."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 12 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Adc4Isr",
            extends: None,
            description: Some("ADC interrupt and status register."),
            bit_size: 32,
            fields: &[
                Field {
                    name: "adrdy",
                    description: Some("ADRDY."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "eosmp",
                    description: Some("EOSMP."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 1 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "eoc",
                    description: Some("EOC."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 2 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "eos",
                    description: Some("EOS."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 3 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "ovr",
                    description: Some("OVR."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 4 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "awd",
                    description: Some("AWD1."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 7 }),
                    bit_size: 1,
                    array: Some(Array::Regular(RegularArray { len: 3, stride: 1 })),
                    enumm: None,
                },
                Field {
                    name: "eocal",
                    description: Some("EOCAL."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 11 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "ldordy",
                    description: Some("LDORDY."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 12 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Adc4Or",
            extends: None,
            description: Some("ADC option register."),
            bit_size: 32,
            fields: &[Field {
                name: "chn21sel",
                description: Some("CHN21SEL."),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 1,
                array: None,
                enumm: None,
            }],
        },
        FieldSet {
            name: "Adc4Pwrr",
            extends: None,
            description: Some("ADC data register."),
            bit_size: 32,
            fields: &[
                Field {
                    name: "autoff",
                    description: Some("AUTOFF."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "dpd",
                    description: Some("DPD."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 1 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "vrefprot",
                    description: Some("VREFPROT."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 2 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "vrefsecsmp",
                    description: Some("VREFSECSMP."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 3 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Adc4Smpr",
            extends: None,
            description: Some("ADC sample time register."),
            bit_size: 32,
            fields: &[
                Field {
                    name: "smp",
                    description: Some("SMP1."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 3,
                    array: Some(Array::Regular(RegularArray { len: 2, stride: 4 })),
                    enumm: Some("Adc4SampleTime"),
                },
                Field {
                    name: "smpsel",
                    description: Some("Channel sampling time selection"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 8 }),
                    bit_size: 1,
                    array: Some(Array::Regular(RegularArray { len: 24, stride: 1 })),
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Awd2cr",
            extends: None,
            description: Some("ADC analog watchdog 2 configuration register."),
            bit_size: 32,
            fields: &[Field {
                name: "awd2ch",
                description: Some("AWD2CH."),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 1,
                array: Some(Array::Regular(RegularArray { len: 20, stride: 1 })),
                enumm: None,
            }],
        },
        FieldSet {
            name: "Awd3cr",
            extends: None,
            description: Some("ADC analog watchdog 3 configuration register."),
            bit_size: 32,
            fields: &[Field {
                name: "awd3ch",
                description: Some("AWD3CH."),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 1,
                array: Some(Array::Regular(RegularArray { len: 20, stride: 1 })),
                enumm: None,
            }],
        },
        FieldSet {
            name: "Calfact",
            extends: None,
            description: Some("ADC user control register."),
            bit_size: 32,
            fields: &[
                Field {
                    name: "i_apb_addr",
                    description: Some("I_APB_ADDR."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 8,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "i_apb_data",
                    description: Some("I_APB_DATA."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 8 }),
                    bit_size: 8,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "validity",
                    description: Some("VALIDITY."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 16 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "latch_coef",
                    description: Some("LATCH_COEF."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 24 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "capture_coef",
                    description: Some("CAPTURE_COEF."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 25 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Calfact2",
            extends: None,
            description: Some("ADC calibration factor register."),
            bit_size: 32,
            fields: &[Field {
                name: "calfact",
                description: Some("CALFACT."),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 32,
                array: None,
                enumm: None,
            }],
        },
        FieldSet {
            name: "Cfgr",
            extends: None,
            description: Some("ADC configuration register."),
            bit_size: 32,
            fields: &[
                Field {
                    name: "dmngt",
                    description: Some("DMNGT."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 2,
                    array: None,
                    enumm: Some("Dmngt"),
                },
                Field {
                    name: "res",
                    description: Some("RES."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 2 }),
                    bit_size: 2,
                    array: None,
                    enumm: Some("Res"),
                },
                Field {
                    name: "extsel",
                    description: Some("EXTSEL."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 5 }),
                    bit_size: 5,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "exten",
                    description: Some("EXTEN."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 10 }),
                    bit_size: 2,
                    array: None,
                    enumm: Some("Exten"),
                },
                Field {
                    name: "ovrmod",
                    description: Some("OVRMOD."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 12 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "cont",
                    description: Some("CONT."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 13 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "autdly",
                    description: Some("AUTDLY."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 14 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "discen",
                    description: Some("DISCEN."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 16 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "discnum",
                    description: Some("DISCNUM."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 17 }),
                    bit_size: 3,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jdiscen",
                    description: Some("JDISCEN."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 20 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "awd1sgl",
                    description: Some("AWD1SGL."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 22 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "awd1en",
                    description: Some("AWD1EN."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 23 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jawd1en",
                    description: Some("JAWD1EN."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 24 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jauto",
                    description: Some("JAUTO."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 25 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "awd1ch",
                    description: Some("AWD1CH."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 26 }),
                    bit_size: 5,
                    array: None,
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Cfgr2",
            extends: None,
            description: Some("ADC configuration register 2."),
            bit_size: 32,
            fields: &[
                Field {
                    name: "rovse",
                    description: Some("ROVSE."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jovse",
                    description: Some("JOVSE."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 1 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "ovss",
                    description: Some("OVSS."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 5 }),
                    bit_size: 4,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "trovs",
                    description: Some("TROVS."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 9 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "rovsm",
                    description: Some("ROVSM."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 10 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "bulb",
                    description: Some("BULB."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 13 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "swtrig",
                    description: Some("SWTRIG."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 14 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "smptrig",
                    description: Some("SMPTRIG."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 15 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "ovsr",
                    description: Some("OVSR."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 16 }),
                    bit_size: 10,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "lftrig",
                    description: Some("LFTRIG."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 27 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "lshift",
                    description: Some("LSHIFT."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 28 }),
                    bit_size: 4,
                    array: None,
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Cr",
            extends: None,
            description: Some("ADC control register."),
            bit_size: 32,
            fields: &[
                Field {
                    name: "aden",
                    description: Some("ADEN."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "addis",
                    description: Some("ADDIS."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 1 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "adstart",
                    description: Some("ADSTART."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 2 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jadstart",
                    description: Some("JADSTART."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 3 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "adstp",
                    description: Some("ADSTP."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 4 }),
                    bit_size: 1,
                    array: None,
                    enumm: Some("Adstp"),
                },
                Field {
                    name: "jadstp",
                    description: Some("JADSTP."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 5 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "adcallin",
                    description: Some("ADCALLIN."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 16 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "calindex",
                    description: Some("CALINDEX."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 24 }),
                    bit_size: 4,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "advregen",
                    description: Some("ADVREGEN."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 28 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "deeppwd",
                    description: Some("DEEPPWD."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 29 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "adcal",
                    description: Some("ADCAL."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 31 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Difsel",
            extends: None,
            description: Some("ADC differential mode selection register."),
            bit_size: 32,
            fields: &[Field {
                name: "difsel",
                description: Some("channel differential or single-ended mode for channel"),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 1,
                array: Some(Array::Regular(RegularArray { len: 20, stride: 1 })),
                enumm: Some("Difsel"),
            }],
        },
        FieldSet {
            name: "Dr",
            extends: None,
            description: Some("ADC regular Data Register."),
            bit_size: 32,
            fields: &[Field {
                name: "rdata",
                description: Some("RDATA."),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 32,
                array: None,
                enumm: None,
            }],
        },
        FieldSet {
            name: "Gcomp",
            extends: None,
            description: Some("ADC gain compensation register."),
            bit_size: 32,
            fields: &[
                Field {
                    name: "gcompcoeff",
                    description: Some("GCOMPCOEFF."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 14,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "gcomp",
                    description: Some("GCOMP."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 31 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Htr1",
            extends: None,
            description: Some("ADC watchdog threshold register 1."),
            bit_size: 32,
            fields: &[
                Field {
                    name: "htr1",
                    description: Some("HTR1."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 25,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "awdfilt1",
                    description: Some("AWDFILT1."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 29 }),
                    bit_size: 3,
                    array: None,
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Htr2",
            extends: None,
            description: Some("ADC watchdog higher threshold register 2."),
            bit_size: 32,
            fields: &[Field {
                name: "htr2",
                description: Some("HTR2."),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 25,
                array: None,
                enumm: None,
            }],
        },
        FieldSet {
            name: "Htr3",
            extends: None,
            description: Some("ADC watchdog higher threshold register 3."),
            bit_size: 32,
            fields: &[Field {
                name: "htr3",
                description: Some("HTR3."),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 25,
                array: None,
                enumm: None,
            }],
        },
        FieldSet {
            name: "Ier",
            extends: None,
            description: Some("ADC interrupt enable register."),
            bit_size: 32,
            fields: &[
                Field {
                    name: "adrdyie",
                    description: Some("ADRDYIE."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "eosmpie",
                    description: Some("EOSMPIE."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 1 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "eocie",
                    description: Some("EOCIE."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 2 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "eosie",
                    description: Some("EOSIE."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 3 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "ovrie",
                    description: Some("OVRIE."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 4 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jeocie",
                    description: Some("JEOCIE."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 5 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jeosie",
                    description: Some("JEOSIE."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 6 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "awdie",
                    description: Some("AWD1IE."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 7 }),
                    bit_size: 1,
                    array: Some(Array::Regular(RegularArray { len: 3, stride: 1 })),
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Isr",
            extends: None,
            description: Some("ADC interrupt and status register."),
            bit_size: 32,
            fields: &[
                Field {
                    name: "adrdy",
                    description: Some("ADRDY."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "eosmp",
                    description: Some("EOSMP."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 1 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "eoc",
                    description: Some("EOC."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 2 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "eos",
                    description: Some("EOS."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 3 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "ovr",
                    description: Some("OVR."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 4 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jeoc",
                    description: Some("JEOC."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 5 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jeos",
                    description: Some("JEOS."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 6 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "awd",
                    description: Some("AWD1."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 7 }),
                    bit_size: 1,
                    array: Some(Array::Regular(RegularArray { len: 3, stride: 1 })),
                    enumm: None,
                },
                Field {
                    name: "ldordy",
                    description: Some("LDORDY."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 12 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Jdr",
            extends: None,
            description: Some("ADC injected data register."),
            bit_size: 32,
            fields: &[Field {
                name: "jdata",
                description: Some("JDATA."),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 32,
                array: None,
                enumm: None,
            }],
        },
        FieldSet {
            name: "Jsqr",
            extends: None,
            description: Some("ADC injected sequence register."),
            bit_size: 32,
            fields: &[
                Field {
                    name: "jl",
                    description: Some("JL."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 2,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jextsel",
                    description: Some("JEXTSEL."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 2 }),
                    bit_size: 5,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jexten",
                    description: Some("JEXTEN."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 7 }),
                    bit_size: 2,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jsq",
                    description: Some("JSQ1."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 9 }),
                    bit_size: 5,
                    array: Some(Array::Regular(RegularArray { len: 4, stride: 6 })),
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Ltr1",
            extends: None,
            description: Some("ADC watchdog threshold register 1."),
            bit_size: 32,
            fields: &[Field {
                name: "ltr1",
                description: Some("LTR1."),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 25,
                array: None,
                enumm: None,
            }],
        },
        FieldSet {
            name: "Ltr2",
            extends: None,
            description: Some("ADC watchdog lower threshold register 2."),
            bit_size: 32,
            fields: &[Field {
                name: "ltr2",
                description: Some("LTR2."),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 25,
                array: None,
                enumm: None,
            }],
        },
        FieldSet {
            name: "Ltr3",
            extends: None,
            description: Some("ADC watchdog lower threshold register 3."),
            bit_size: 32,
            fields: &[Field {
                name: "ltr3",
                description: Some("LTR3."),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 25,
                array: None,
                enumm: None,
            }],
        },
        FieldSet {
            name: "Ofr",
            extends: None,
            description: Some("ADC offset register."),
            bit_size: 32,
            fields: &[
                Field {
                    name: "offset",
                    description: Some("OFFSET."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 24,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "posoff",
                    description: Some("POSOFF."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 24 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "usat",
                    description: Some("USAT."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 25 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "ssat",
                    description: Some("SSAT."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 26 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "offset_ch",
                    description: Some("OFFSET_CH."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 27 }),
                    bit_size: 5,
                    array: None,
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Pcsel",
            extends: None,
            description: Some("ADC channel preselection register."),
            bit_size: 32,
            fields: &[Field {
                name: "pcsel",
                description: Some("PCSEL."),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 1,
                array: Some(Array::Regular(RegularArray { len: 20, stride: 1 })),
                enumm: Some("Pcsel"),
            }],
        },
        FieldSet {
            name: "Smpr",
            extends: None,
            description: Some("ADC sample time register 1."),
            bit_size: 32,
            fields: &[Field {
                name: "smp",
                description: Some("SMP0."),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 3,
                array: Some(Array::Regular(RegularArray { len: 10, stride: 3 })),
                enumm: Some("SampleTime"),
            }],
        },
        FieldSet {
            name: "Sqr1",
            extends: None,
            description: Some("ADC regular sequence register 1."),
            bit_size: 32,
            fields: &[
                Field {
                    name: "l",
                    description: Some("L."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 4,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "sq",
                    description: Some("SQ1."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 6 }),
                    bit_size: 5,
                    array: Some(Array::Regular(RegularArray { len: 4, stride: 6 })),
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Sqr2",
            extends: None,
            description: Some("ADC regular sequence register 2."),
            bit_size: 32,
            fields: &[Field {
                name: "sq",
                description: Some("SQ5."),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 5,
                array: Some(Array::Regular(RegularArray { len: 5, stride: 6 })),
                enumm: None,
            }],
        },
        FieldSet {
            name: "Sqr3",
            extends: None,
            description: Some("ADC regular sequence register 3."),
            bit_size: 32,
            fields: &[Field {
                name: "sq",
                description: Some("SQ10."),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 5,
                array: Some(Array::Regular(RegularArray { len: 5, stride: 6 })),
                enumm: None,
            }],
        },
        FieldSet {
            name: "Sqr4",
            extends: None,
            description: Some("ADC regular sequence register 4."),
            bit_size: 32,
            fields: &[Field {
                name: "sq",
                description: Some("SQ15."),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 5,
                array: Some(Array::Regular(RegularArray { len: 2, stride: 6 })),
                enumm: None,
            }],
        },
    ],
    enums: &[
        Enum {
            name: "Adc4Dmacfg",
            description: None,
            bit_size: 1,
            variants: &[
                EnumVariant {
                    name: "ONE_SHOT",
                    description: Some("DMA One Shot mode selected"),
                    value: 0,
                },
                EnumVariant {
                    name: "CIRCULAR",
                    description: Some("DMA Circular mode selected"),
                    value: 1,
                },
            ],
        },
        Enum {
            name: "Adc4Exten",
            description: None,
            bit_size: 2,
            variants: &[
                EnumVariant {
                    name: "DISABLED",
                    description: Some("Trigger detection disabled"),
                    value: 0,
                },
                EnumVariant {
                    name: "RISING_EDGE",
                    description: Some("Trigger detection on the rising edge"),
                    value: 1,
                },
                EnumVariant {
                    name: "FALLING_EDGE",
                    description: Some("Trigger detection on the falling edge"),
                    value: 2,
                },
                EnumVariant {
                    name: "BOTH_EDGES",
                    description: Some("Trigger detection on both the rising and falling edges"),
                    value: 3,
                },
            ],
        },
        Enum {
            name: "Adc4OversamplingRatio",
            description: None,
            bit_size: 3,
            variants: &[
                EnumVariant {
                    name: "OVERSAMPLE2X",
                    description: Some("Oversample 2 times"),
                    value: 0,
                },
                EnumVariant {
                    name: "OVERSAMPLE4X",
                    description: Some("Oversample 4 times"),
                    value: 1,
                },
                EnumVariant {
                    name: "OVERSAMPLE8X",
                    description: Some("Oversample 8 times"),
                    value: 2,
                },
                EnumVariant {
                    name: "OVERSAMPLE16X",
                    description: Some("Oversample 16 times"),
                    value: 3,
                },
                EnumVariant {
                    name: "OVERSAMPLE32X",
                    description: Some("Oversample 32 times"),
                    value: 4,
                },
                EnumVariant {
                    name: "OVERSAMPLE64X",
                    description: Some("Oversample 64 times"),
                    value: 5,
                },
                EnumVariant {
                    name: "OVERSAMPLE128X",
                    description: Some("Oversample 128 times"),
                    value: 6,
                },
                EnumVariant {
                    name: "OVERSAMPLE256X",
                    description: Some("Oversample 256 times"),
                    value: 7,
                },
            ],
        },
        Enum {
            name: "Adc4Presc",
            description: None,
            bit_size: 4,
            variants: &[
                EnumVariant {
                    name: "DIV1",
                    description: Some("adc_ker_ck_input not divided"),
                    value: 0,
                },
                EnumVariant {
                    name: "DIV2",
                    description: Some("adc_ker_ck_input divided by 2"),
                    value: 1,
                },
                EnumVariant {
                    name: "DIV4",
                    description: Some("adc_ker_ck_input divided by 4"),
                    value: 2,
                },
                EnumVariant {
                    name: "DIV6",
                    description: Some("adc_ker_ck_input divided by 6"),
                    value: 3,
                },
                EnumVariant {
                    name: "DIV8",
                    description: Some("adc_ker_ck_input divided by 8"),
                    value: 4,
                },
                EnumVariant {
                    name: "DIV10",
                    description: Some("adc_ker_ck_input divided by 10"),
                    value: 5,
                },
                EnumVariant {
                    name: "DIV12",
                    description: Some("adc_ker_ck_input divided by 12"),
                    value: 6,
                },
                EnumVariant {
                    name: "DIV16",
                    description: Some("adc_ker_ck_input divided by 16"),
                    value: 7,
                },
                EnumVariant {
                    name: "DIV32",
                    description: Some("adc_ker_ck_input divided by 32"),
                    value: 8,
                },
                EnumVariant {
                    name: "DIV64",
                    description: Some("adc_ker_ck_input divided by 64"),
                    value: 9,
                },
                EnumVariant {
                    name: "DIV128",
                    description: Some("adc_ker_ck_input divided by 128"),
                    value: 10,
                },
                EnumVariant {
                    name: "DIV256",
                    description: Some("adc_ker_ck_input divided by 256"),
                    value: 11,
                },
            ],
        },
        Enum {
            name: "Adc4Res",
            description: None,
            bit_size: 2,
            variants: &[
                EnumVariant {
                    name: "BITS12",
                    description: Some("12-bit resolution"),
                    value: 0,
                },
                EnumVariant {
                    name: "BITS10",
                    description: Some("10-bit resolution"),
                    value: 1,
                },
                EnumVariant {
                    name: "BITS8",
                    description: Some("8-bit resolution"),
                    value: 2,
                },
                EnumVariant {
                    name: "BITS6",
                    description: Some("6-bit resolution"),
                    value: 3,
                },
            ],
        },
        Enum {
            name: "Adc4SampleTime",
            description: None,
            bit_size: 3,
            variants: &[
                EnumVariant {
                    name: "CYCLES1_5",
                    description: Some("1.5 ADC cycles"),
                    value: 0,
                },
                EnumVariant {
                    name: "CYCLES3_5",
                    description: Some("3.5 ADC cycles"),
                    value: 1,
                },
                EnumVariant {
                    name: "CYCLES7_5",
                    description: Some("7.5 ADC cycles"),
                    value: 2,
                },
                EnumVariant {
                    name: "CYCLES12_5",
                    description: Some("12.5 ADC cycles"),
                    value: 3,
                },
                EnumVariant {
                    name: "CYCLES19_5",
                    description: Some("19.5 ADC cycles"),
                    value: 4,
                },
                EnumVariant {
                    name: "CYCLES39_5",
                    description: Some("39.5 ADC cycles"),
                    value: 5,
                },
                EnumVariant {
                    name: "CYCLES79_5",
                    description: Some("79.5 ADC cycles"),
                    value: 6,
                },
                EnumVariant {
                    name: "CYCLES814_5",
                    description: Some("160.5 ADC cycles"),
                    value: 7,
                },
            ],
        },
        Enum {
            name: "Adstp",
            description: None,
            bit_size: 1,
            variants: &[EnumVariant {
                name: "STOP",
                description: Some("Stop conversion of channel"),
                value: 1,
            }],
        },
        Enum {
            name: "Difsel",
            description: None,
            bit_size: 1,
            variants: &[
                EnumVariant {
                    name: "SINGLE_ENDED",
                    description: Some("Input channel is configured in single-ended mode"),
                    value: 0,
                },
                EnumVariant {
                    name: "DIFFERENTIAL",
                    description: Some("Input channel is configured in differential mode"),
                    value: 1,
                },
            ],
        },
        Enum {
            name: "Dmngt",
            description: None,
            bit_size: 2,
            variants: &[
                EnumVariant {
                    name: "DR",
                    description: Some("Store output data in DR only"),
                    value: 0,
                },
                EnumVariant {
                    name: "DMA_ONE_SHOT",
                    description: Some("DMA One Shot Mode selected"),
                    value: 1,
                },
                EnumVariant {
                    name: "MDF",
                    description: Some("MDF mode selected"),
                    value: 2,
                },
                EnumVariant {
                    name: "DMA_CIRCULAR",
                    description: Some("DMA Circular Mode selected"),
                    value: 3,
                },
            ],
        },
        Enum {
            name: "Exten",
            description: None,
            bit_size: 2,
            variants: &[
                EnumVariant {
                    name: "DISABLED",
                    description: Some("Trigger detection disabled"),
                    value: 0,
                },
                EnumVariant {
                    name: "RISING_EDGE",
                    description: Some("Trigger detection on the rising edge"),
                    value: 1,
                },
                EnumVariant {
                    name: "FALLING_EDGE",
                    description: Some("Trigger detection on the falling edge"),
                    value: 2,
                },
                EnumVariant {
                    name: "BOTH_EDGES",
                    description: Some("Trigger detection on both the rising and falling edges"),
                    value: 3,
                },
            ],
        },
        Enum {
            name: "Pcsel",
            description: None,
            bit_size: 1,
            variants: &[
                EnumVariant {
                    name: "NOT_PRESELECTED",
                    description: Some("Input channel x is not pre-selected"),
                    value: 0,
                },
                EnumVariant {
                    name: "PRESELECTED",
                    description: Some("Pre-select input channel x"),
                    value: 1,
                },
            ],
        },
        Enum {
            name: "Res",
            description: None,
            bit_size: 2,
            variants: &[
                EnumVariant {
                    name: "BITS14",
                    description: Some("14-bit resolution"),
                    value: 0,
                },
                EnumVariant {
                    name: "BITS12",
                    description: Some("12-bit resolution"),
                    value: 1,
                },
                EnumVariant {
                    name: "BITS10",
                    description: Some("10-bit resolution"),
                    value: 2,
                },
                EnumVariant {
                    name: "BITS8",
                    description: Some("8-bit resolution"),
                    value: 3,
                },
            ],
        },
        Enum {
            name: "SampleTime",
            description: None,
            bit_size: 3,
            variants: &[
                EnumVariant {
                    name: "CYCLES1_5",
                    description: Some("1.5 ADC cycles"),
                    value: 0,
                },
                EnumVariant {
                    name: "CYCLES3_5",
                    description: Some("3.5 ADC cycles"),
                    value: 1,
                },
                EnumVariant {
                    name: "CYCLES7_5",
                    description: Some("7.5 ADC cycles"),
                    value: 2,
                },
                EnumVariant {
                    name: "CYCLES12_5",
                    description: Some("12.5 ADC cycles"),
                    value: 3,
                },
                EnumVariant {
                    name: "CYCLES19_5",
                    description: Some("19.5 ADC cycles"),
                    value: 4,
                },
                EnumVariant {
                    name: "CYCLES39_5",
                    description: Some("39.5 ADC cycles"),
                    value: 5,
                },
                EnumVariant {
                    name: "CYCLES79_5",
                    description: Some("79.5 ADC cycles"),
                    value: 6,
                },
                EnumVariant {
                    name: "CYCLES160_5",
                    description: Some("160.5 ADC cycles"),
                    value: 7,
                },
            ],
        },
    ],
};
